/*
 * 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
 *你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
 *
 * [1] 两数之和
 */
/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
  // let result = [],bstop= false;
  // for (let i = 0; i < nums.length; i++) {
  //   if(bstop){
  //     break;
  //   }
  //   const ele = nums[i];
  //   for (let j =  i + 1; j < nums.length; j++) {
  //     const ele2 = nums[j];
  //     if (ele + ele2 === target) {
  //       result = [i,j];
  //       bstop = true;
  //       break;
  //     }
  //   }
  // }
  // return result

  // 降低空间复杂度
  // for (let i = 0; i < nums.length; i++) {
  //   const ele = nums[i];
  //   let j = nums.indexOf(target-ele,i+1)
  //   if(j !== -1){
  //     return [i,j]
  //   }
  // }

  // 使用map表 降低时间复杂度
  let map = new Map();
  for (let i = 0; i < nums.length; i++) {
    if (map.has(target - nums[i])) {
      return [map.get(target - nums[i]), i];
    }
    map.set(nums[i], i);
  }
};

/*
 * [2] 两数相加
 * 
 * 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
  如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
  您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
 */
/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
  // 非链表解题
  // if (!l1.length && !l2.length) {
  //   return '无效值';
  // }
  // let ListMax = l1.length > l2.length ? l1 : l2;
  // let ListMin = l1.length > l2.length ? l2 : l1;

  // let sum = 0,
  //   arr = [];

  // for (let i = 0; i < ListMin.length; i++) {
  //   const ele = ListMin[i];
  //   sum += (ListMin[i] + ListMax[i]) * Math.pow(10, i);
  // }

  // for (let j = ListMin.length; j < ListMax.length; j++) {
  //   const ele = ListMax[j];
  //   sum += ListMax[i] * Math.pow(10, i);
  // }

  // while (sum > 10) {
  //   arr.push(sum % 10);
  //   sum = parseInt(sum / 10);
  // }
  // arr.push(sum);
  // return arr;

  // 链表https://www.jianshu.com/p/f254ec665e57
  // function Node(ele) {
  //   this.ele  = ele;
  //   this.next = null
  // }

  // //链表类
  // function LList () {
  //   this.head = new Node( 'head' );     //头节点
  //   this.find = find;                   //查找节点
  //   this.insert = insert;               //插入节点
  //   this.remove = remove;               //删除节点
  //   this.findPrev = findPrev;           //查找前一个节点
  //   this.display = display;             //显示链表
  // }

  let result = new ListNode(null);
  let nextRst = result;
  // 进位
  let params = 0; // 传给下一个层级的值
  let val = 0; // 传给当前层级的值

  while (l1 != null || l2 != null) {
    // TODO
    let x = l1 != null ? l1.val : 0;
    let y = l2 != null ? l2.val : 0;

    val = (x + y + params) % 10;
    params = Math.floor((x + y + params) / 10);

    nextRst.next = new ListNode(val);
    nextRst = nextRst.next;

    if (l1 != null) l1 = l1.next;
    if (l2 != null) l2 = l2.next;
  }

  if (params) {
    nextRst.next = new ListNode(params);
  }

  return result.next;
};
// console.log(addTwoNumbers([2, 4, 3], [5, 6, 4]));


/*
 * 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
 *
 * [3] 无重复字符的最长子串
 */
/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLongestSubstring = function(s) {

  // 暴力法 时间复杂度太大
  let arrStr = s.split(''),
    maxLen = 0;

  for (let i = 0; i < arrStr.length; i++) {
    const element = arrStr;
    deepArr(element.slice(i));
  }
  
  function deepArr(arr) {
    let maxArr = [];
    arr.forEach((ele, index) => {
      if (maxArr.indexOf(ele) === -1) {
        maxArr.push(ele);
        maxLen < maxArr.length ? (maxLen = maxArr.length) : null;
      } else {
        maxLen < maxArr.length ? (maxLen = maxArr.length) : null;
        maxArr = [];
        // maxArr.push(ele);
      }
      // console.log(index, ele, maxArr, maxArr.indexOf(ele) === -1);
    });
  }
  return maxLen;
};
// console.log(lengthOfLongestSubstring(' '));






